/*****************************************************************************
 * Copyright (c) 2019, Nations Technologies Inc.
 *
 * All rights reserved.
 * ****************************************************************************
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the disclaimer below.
 *
 * Nations' name may not be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY NATIONS "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
 * DISCLAIMED. IN NO EVENT SHALL NATIONS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * ****************************************************************************/

/**
 * @file sdio_sdcard.h
 * @author Nations
 * @version v1.0.2
 *
 * @copyright Copyright (c) 2019, Nations Technologies Inc. All rights reserved.
 */
#ifndef __SDIO_SDCARD_H__
#define __SDIO_SDCARD_H__

#include "n32g45x.h"
//#include "test.h"

typedef enum
{
    /**
     * @brief  SDIO specific error defines
     */
    SD_CMD_CRC_FAIL     = (1),  /*!< Command response received (but CRC check failed) */
    SD_DATA_CRC_FAIL    = (2),  /*!< Data bock sent/received (CRC check Failed) */
    SD_CMD_RSP_TIMEOUT  = (3),  /*!< Command response timeout */
    SD_DATA_TIMEOUT     = (4),  /*!< Data time out */
    SD_TX_UNDERRUN      = (5),  /*!< Transmit DATFIFO under-run */
    SD_RX_OVERRUN       = (6),  /*!< Receive DATFIFO over-run */
    SD_START_BIT_ERR    = (7),  /*!< Start bit not detected on all data signals in widE bus mode */
    SD_CMD_OUT_OF_RANGE = (8),  /*!< CMDCTRL's argument was out of range.*/
    SD_ADDR_MISALIGNED  = (9),  /*!< Misaligned address */
    SD_BLOCK_LEN_ERR    = (10), /*!< Transferred block length is not allowed for the card or the number of transferred
                                   bytes does not match the block length */
    SD_ERASE_SEQ_ERR        = (11), /*!< An error in the sequence of erase command occurs.*/
    SD_BAD_ERASE_PARAM      = (12), /*!< An Invalid selection for erase groups */
    SD_WRITE_PROT_VIOLATION = (13), /*!< Attempt to program a write protect block */
    SD_LOCK_UNLOCK_FAILED = (14), /*!< Sequence or password error has been detected in unlock command or if there was an
                                     attempt to access a locked card */
    SD_COM_CRC_FAILED        = (15), /*!< CRC check of the previous command failed */
    SD_ILLEGAL_CMD           = (16), /*!< Command is not legal for the card state */
    SD_CARD_ECC_FAILED       = (17), /*!< Card internal ECC was applied but failed to correct the data */
    SD_CC_ERROR              = (18), /*!< Internal card controller error */
    SD_GENERAL_UNKNOWN_ERROR = (19), /*!< General or Unknown error */
    SD_STREAM_READ_UNDERRUN  = (20), /*!< The card could not sustain data transfer in stream read operation. */
    SD_STREAM_WRITE_OVERRUN  = (21), /*!< The card could not sustain data programming in stream mode */
    SD_CID_CSD_OVERWRITE     = (22), /*!< CID/CSD overwrite error */
    SD_WP_ERASE_SKIP         = (23), /*!< only partial address space was erased */
    SD_CARD_ECC_DISABLED     = (24), /*!< Command has been executed without using internal ECC */
    SD_ERASE_RESET =
        (25), /*!< Erase sequence was cleared before executing because an out of erase sequence command was received */
    SD_AKE_SEQ_ERROR         = (26), /*!< Error in sequence of authentication. */
    SD_INVALID_VOLTRANGE     = (27),
    SD_ADDR_OUT_OF_RANGE     = (28),
    SD_SWITCH_ERROR          = (29),
    SD_SDIO_DISABLED         = (30),
    SD_SDIO_FUNCTION_BUSY    = (31),
    SD_SDIO_FUNCTION_FAILED  = (32),
    SD_SDIO_UNKNOWN_FUNCTION = (33),

    /**
     * @brief  Standard error defines
     */
    SD_INTERNAL_ERROR,
    SD_NOT_CONFIGURED,
    SD_REQUEST_PENDING,
    SD_REQUEST_NOT_APPLICABLE,
    SD_INVALID_PARAMETER,
    SD_UNSUPPORTED_FEATURE,
    SD_UNSUPPORTED_HW,
    SD_ERROR,
    SD_OK = 0
} SD_Error;

/**
 * @brief  SDIO Transfer state
 */
typedef enum
{
    SD_TRANSFER_OK   = 0,
    SD_TRANSFER_BUSY = 1,
    SD_TRANSFER_ERROR
} SDTransferState;

/**
 * @brief  SD Card States
 */
typedef enum
{
    SD_CARD_READY          = ((uint32_t)0x00000001),
    SD_CARD_IDENTIFICATION = ((uint32_t)0x00000002),
    SD_CARD_STANDBY        = ((uint32_t)0x00000003),
    SD_CARD_TRANSFER       = ((uint32_t)0x00000004),
    SD_CARD_SENDING        = ((uint32_t)0x00000005),
    SD_CARD_RECEIVING      = ((uint32_t)0x00000006),
    SD_CARD_PROGRAMMING    = ((uint32_t)0x00000007),
    SD_CARD_DISCONNECTED   = ((uint32_t)0x00000008),
    SD_CARD_ERROR          = ((uint32_t)0x000000FF)
} SDCardState;

/**
 * @brief  Card Specific Data: CSD Register
 */
typedef struct
{
    __IO uint8_t CSDStruct;           /*!< CSD structure */
    __IO uint8_t SysSpecVersion;      /*!< System specification version */
    __IO uint8_t Reserved1;           /*!< Reserved */
    __IO uint8_t TAAC;                /*!< Data read access-time 1 */
    __IO uint8_t NSAC;                /*!< Data read access-time 2 in CLK cycles */
    __IO uint8_t MaxBusClkFrec;       /*!< Max. bus clock frequency */
    __IO uint16_t CardComdClasses;    /*!< Card command classes */
    __IO uint8_t RdBlockLen;          /*!< Max. read data block length */
    __IO uint8_t PartBlockRead;       /*!< Partial blocks for read allowed */
    __IO uint8_t WrBlockMisalign;     /*!< Write block misalignment */
    __IO uint8_t RdBlockMisalign;     /*!< Read block misalignment */
    __IO uint8_t DSRImpl;             /*!< DSR implemented */
    __IO uint8_t Reserved2;           /*!< Reserved */
    __IO uint32_t DeviceSize;         /*!< Device Size */
    __IO uint8_t MaxRdCurrentVDDMin;  /*!< Max. read current @ VDD min */
    __IO uint8_t MaxRdCurrentVDDMax;  /*!< Max. read current @ VDD max */
    __IO uint8_t MaxWrCurrentVDDMin;  /*!< Max. write current @ VDD min */
    __IO uint8_t MaxWrCurrentVDDMax;  /*!< Max. write current @ VDD max */
    __IO uint8_t DeviceSizeMul;       /*!< Device size multiplier */
    __IO uint8_t EraseGrSize;         /*!< Erase group size */
    __IO uint8_t EraseGrMul;          /*!< Erase group size multiplier */
    __IO uint8_t WrProtectGrSize;     /*!< Write protect group size */
    __IO uint8_t WrProtectGrEnable;   /*!< Write protect group enable */
    __IO uint8_t ManDeflECC;          /*!< Manufacturer default ECC */
    __IO uint8_t WrSpeedFact;         /*!< Write speed factor */
    __IO uint8_t MaxWrBlockLen;       /*!< Max. write data block length */
    __IO uint8_t WriteBlockPaPartial; /*!< Partial blocks for write allowed */
    __IO uint8_t Reserved3;           /*!< Reserded */
    __IO uint8_t ContentProtectAppli; /*!< Content protection application */
    __IO uint8_t FileFormatGrouop;    /*!< File format group */
    __IO uint8_t CopyFlag;            /*!< Copy flag (OTP) */
    __IO uint8_t PermWrProtect;       /*!< Permanent write protection */
    __IO uint8_t TempWrProtect;       /*!< Temporary write protection */
    __IO uint8_t FileFormat;          /*!< File Format */
    __IO uint8_t ECC;                 /*!< ECC code */
    __IO uint8_t CSD_CRC;             /*!< CSD CRC */
    __IO uint8_t Reserved4;           /*!< always 1*/
} SD_CSD;

/**
 * @brief  Card Identification Data: CID Register
 */
typedef struct
{
    __IO uint8_t ManufacturerID; /*!< ManufacturerID */
    __IO uint16_t OEM_AppliID;   /*!< OEM/Application ID */
    __IO uint32_t ProdName1;     /*!< Product Name part1 */
    __IO uint8_t ProdName2;      /*!< Product Name part2*/
    __IO uint8_t ProdRev;        /*!< Product Revision */
    __IO uint32_t ProdSN;        /*!< Product Serial Number */
    __IO uint8_t Reserved1;      /*!< Reserved1 */
    __IO uint16_t ManufactDate;  /*!< Manufacturing Date */
    __IO uint8_t CID_CRC;        /*!< CID CRC */
    __IO uint8_t Reserved2;      /*!< always 1 */
} SD_CID;

/**
 * @brief SD Card Status
 */
typedef struct
{
    __IO uint8_t DAT_BUS_WIDTH;
    __IO uint8_t SECURED_MODE;
    __IO uint16_t SD_CARD_TYPE;
    __IO uint32_t SIZE_OF_PROTECTED_AREA;
    __IO uint8_t SPEED_CLASS;
    __IO uint8_t PERFORMANCE_MOVE;
    __IO uint8_t AU_SIZE;
    __IO uint16_t ERASE_SIZE;
    __IO uint8_t ERASE_TIMEOUT;
    __IO uint8_t ERASE_OFFSET;
} SD_CardStatus;

/**
 * @brief SD Card information
 */
typedef struct
{
    SD_CSD SD_csd;
    SD_CID SD_cid;
    long long CardCapacity;  /*!< Card Capacity */
    uint32_t CardBlockSize; /*!< Card Block Size */
    uint16_t RCA;
    uint8_t CardType;
} SD_CardInfo;

extern SD_CardInfo SDCardInfo;

/*???*/
#define SDIO_FIFO_ADDRESS ((uint32_t)0x40018080) // SDIO_FIOF_ADDR=SDIO_base+0x80->sdio_base+0xfc
/**
 * @brief  SDIO Intialization Frequency (400KHz max)
 */
#define SDIO_INIT_CLK_DIV ((uint8_t)0xB2)
/**
 * @brief  SDIO Data Transfer Frequency (25MHz max)
 */
/*!< SDIOCLK = HCLK, SDIO_CK = HCLK/(2 + SDIO_TRANSFER_CLK_DIV) */
#define SDIO_TRANSFER_CLK_DIV ((uint8_t)0x01)

/**
 * @brief SDIO Commands  Index
 */
#define SD_CMD_GO_IDLE_STATE        ((uint8_t)0)
#define SD_CMD_SEND_OP_COND         ((uint8_t)1)
#define SD_CMD_ALL_SEND_CID         ((uint8_t)2)
#define SD_CMD_SET_REL_ADDR         ((uint8_t)3) /*!< SDIO_SEND_REL_ADDR for SD Card */
#define SD_CMD_SET_DSR              ((uint8_t)4)
#define SD_CMD_SDIO_SEN_OP_COND     ((uint8_t)5)
#define SD_CMD_HS_SWITCH            ((uint8_t)6)
#define SD_CMD_SEL_DESEL_CARD       ((uint8_t)7)
#define SD_CMD_HS_SEND_EXT_CSD      ((uint8_t)8)
#define SD_CMD_SEND_CSD             ((uint8_t)9)
#define SD_CMD_SEND_CID             ((uint8_t)10)
#define SD_CMD_READ_DAT_UNTIL_STOP  ((uint8_t)11) /*!< SD Card doesn't support it */
#define SD_CMD_STOP_TRANSMISSION    ((uint8_t)12)
#define SD_CMD_SEND_STATUS          ((uint8_t)13)
#define SD_CMD_HS_BUSTEST_READ      ((uint8_t)14)
#define SD_CMD_GO_INACTIVE_STATE    ((uint8_t)15)
#define SD_CMD_SET_BLOCKLEN         ((uint8_t)16)
#define SD_CMD_READ_SINGLE_BLOCK    ((uint8_t)17)
#define SD_CMD_READ_MULT_BLOCK      ((uint8_t)18)
#define SD_CMD_HS_BUSTEST_WRITE     ((uint8_t)19)
#define SD_CMD_WRITE_DAT_UNTIL_STOP ((uint8_t)20) /*!< SD Card doesn't support it */
#define SD_CMD_SET_BLOCK_COUNT      ((uint8_t)23) /*!< SD Card doesn't support it */
#define SD_CMD_WRITE_SINGLE_BLOCK   ((uint8_t)24)
#define SD_CMD_WRITE_MULT_BLOCK     ((uint8_t)25)
#define SD_CMD_PROG_CID             ((uint8_t)26) /*!< reserved for manufacturers */
#define SD_CMD_PROG_CSD             ((uint8_t)27)
#define SD_CMD_SET_WRITE_PROT       ((uint8_t)28)
#define SD_CMD_CLR_WRITE_PROT       ((uint8_t)29)
#define SD_CMD_SEND_WRITE_PROT      ((uint8_t)30)
#define SD_CMD_SD_ERASE_GRP_START                                                                                      \
    ((uint8_t)32) /*!< To set the address of the first write                                                           \
                   block to be erased. (For SD card only) */
#define SD_CMD_SD_ERASE_GRP_END                                                                                        \
    ((uint8_t)33) /*!< To set the address of the last write block of the                                               \
                   continuous range to be erased. (For SD card only) */
#define SD_CMD_ERASE_GRP_START                                                                                         \
    ((uint8_t)35) /*!< To set the address of the first write block to be erased.                                       \
                   (For MMC card only spec 3.31) */

#define SD_CMD_ERASE_GRP_END                                                                                           \
    ((uint8_t)36) /*!< To set the address of the last write block of the                                               \
                   continuous range to be erased. (For MMC card only spec 3.31) */

#define SD_CMD_ERASE        ((uint8_t)38)
#define SD_CMD_FAST_IO      ((uint8_t)39) /*!< SD Card doesn't support it */
#define SD_CMD_GO_IRQ_STATE ((uint8_t)40) /*!< SD Card doesn't support it */
#define SD_CMD_LOCK_UNLOCK  ((uint8_t)42)
#define SD_CMD_APP_CMD      ((uint8_t)55)
#define SD_CMD_GEN_CMD      ((uint8_t)56)
#define SD_CMD_NO_CMD       ((uint8_t)64)

/**
 * @brief Following commands are SD Card Specific commands.
 *        SDIO_APP_CMD :CMD55 should be sent before sending these commands.
 */
#define SD_CMD_APP_SD_SET_BUSWIDTH          ((uint8_t)6)  /*!< For SD Card only */
#define SD_CMD_SD_APP_STAUS                 ((uint8_t)13) /*!< For SD Card only */
#define SD_CMD_SD_APP_SEND_NUM_WRITE_BLOCKS ((uint8_t)22) /*!< For SD Card only */
#define SD_CMD_SD_APP_OP_COND               ((uint8_t)41) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CLR_CARD_DETECT   ((uint8_t)42) /*!< For SD Card only */
#define SD_CMD_SD_APP_SEND_SCR              ((uint8_t)51) /*!< For SD Card only */
#define SD_CMD_SDIO_RW_DIRECT               ((uint8_t)52) /*!< For SD I/O Card only */
#define SD_CMD_SDIO_RW_EXTENDED             ((uint8_t)53) /*!< For SD I/O Card only */

/**
 * @brief Following commands are SD Card Specific security commands.
 *        SDIO_APP_CMD should be sent before sending these commands.
 */
#define SD_CMD_SD_APP_GET_MKB                     ((uint8_t)43) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_MID                     ((uint8_t)44) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CER_RN1                 ((uint8_t)45) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_CER_RN2                 ((uint8_t)46) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CER_RES2                ((uint8_t)47) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_CER_RES1                ((uint8_t)48) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_READ_MULTIPLE_BLOCK  ((uint8_t)18) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_WRITE_MULTIPLE_BLOCK ((uint8_t)25) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_ERASE                ((uint8_t)38) /*!< For SD Card only */
#define SD_CMD_SD_APP_CHANGE_SECURE_AREA          ((uint8_t)49) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_WRITE_MKB            ((uint8_t)48) /*!< For SD Card only */

/* Uncomment the following line to select the SDIO Data transfer mode */
#define SD_DMA_MODE ((uint32_t)0x00000000)
//#define SD_POLLING_MODE                            ((uint32_t)0x00000002)

/**
 * @brief  SD detection on its memory slot
 */
#define SD_PRESENT     ((uint8_t)0x01)
#define SD_NOT_PRESENT ((uint8_t)0x00)

/**
 * @brief Supported SD Memory Cards
 */
#define SDIO_STD_CAPACITY_SD_CARD_V1_1    ((uint32_t)0x00000000)
#define SDIO_STD_CAPACITY_SD_CARD_V2_0    ((uint32_t)0x00000001)
#define SDIO_HIGH_CAPACITY_SD_CARD        ((uint32_t)0x00000002)
#define SDIO_MULTIMEDIA_CARD              ((uint32_t)0x00000003)
#define SDIO_SECURE_DIGITAL_IO_CARD       ((uint32_t)0x00000004)
#define SDIO_HIGH_SPEED_MULTIMEDIA_CARD   ((uint32_t)0x00000005)
#define SDIO_SECURE_DIGITAL_IO_COMBO_CARD ((uint32_t)0x00000006)
#define SDIO_HIGH_CAPACITY_MMC_CARD       ((uint32_t)0x00000007)

void SD_DeInit(void);
SD_Error SD_Init(u32 ClockBypass, u32 TransClkDiv, u32 BusWidth);
SDTransferState SD_GetStatus(void);
SDCardState SD_GetState(void);
uint8_t SD_Detect(void);
SD_Error SD_PowerON(void);
SD_Error SD_PowerOFF(void);
SD_Error SD_InitializeCards(void);
SD_Error SD_GetCardInfo(SD_CardInfo* cardinfo);
SD_Error SD_GetCardStatus(SD_CardStatus* cardstatus);
SD_Error SD_EnableWideBusOperation(uint32_t WideMode);
SD_Error SD_SelectDeselect(uint32_t addr);
SD_Error SD_ReadBlock(uint8_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize);
SD_Error SD_ReadBlock_ForIrqTest(uint8_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize);
SD_Error SD_ReadBlock_ForDblockSize(uint8_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize);
SD_Error SD_ReadBlock_ForDtimer(uint8_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize, uint32_t Dtimeout);
SD_Error SD_ReadBlock_ForMMCGetExtCSD(uint8_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize);
SD_Error SD_ReadBlock_ForCMD6Mode1(uint32_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize);
SD_Error SD_ReadBlock_ForCMD6Mode0(uint32_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize);
SD_Error SD_ReadBlock_ForDMATest(uint8_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize, u32 DMA_ch);
SD_Error CmdResp1Error(uint8_t cmd);
void GPIO_Configuration(void);

SD_Error SD_ReadBlock_ForSCR(uint8_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize);

SD_Error SD_WriteBlock_ForWaitPend(uint8_t* writebuff, uint32_t WriteAddr, uint16_t BlockSize);
SD_Error SD_ReadBlock_ForWaitPend(uint8_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize);
SD_Error SD_WriteBlock_ForWaitInt(uint8_t* writebuff, uint32_t WriteAddr, uint16_t BlockSize);

SD_Error SD_ReadMultiBlocks(uint8_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);
SD_Error SD_WriteBlock(uint8_t* writebuff, uint32_t WriteAddr, uint16_t BlockSize);
SD_Error SD_WriteBlock_ForDMATest(uint8_t* writebuff, uint32_t WriteAddr, uint16_t BlockSize, u32 DMA_ch);
SD_Error SD_WriteBlock_ForIrqTest(uint8_t* writebuff, uint32_t WriteAddr, uint16_t BlockSize);
SD_Error SD_WriteBlock_ForFIFOCnt(uint8_t* writebuff, uint32_t WriteAddr, uint16_t BlockSize);
SD_Error SD_WriteBlock_ForDblockSize(uint8_t* writebuff, uint32_t WriteAddr, uint16_t BlockSize);
SD_Error SD_CMD12(void);
SD_Error SD_ReadBlock_ForStreamRead(uint8_t* readbuff, uint32_t ReadAddr, uint16_t BlockSize);
SD_Error SD_WriteBlock_ForStreamWrite(uint8_t* writebuff, uint32_t WriteAddr, uint16_t BlockSize);

SD_Error SD_CMD16_BlockSize(u32 block_size);

SD_Error SD_WriteBlock_ForLockUnlock(uint8_t* writebuff, uint16_t BlockSize);
SD_Error SD_GetACMD22(uint32_t* pscr);

SD_Error SD_WriteMultiBlocks(uint8_t* writebuff, uint32_t WriteAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);
SDTransferState SD_GetTransferState(void);
SD_Error SD_StopTransfer(void);
SD_Error SD_Erase(uint32_t startaddr, uint32_t endaddr);
SD_Error SD_SendStatus(uint32_t* pcardstatus);
SD_Error SD_SendSDStatus(uint32_t* psdstatus);
SD_Error SD_ProcessIRQSrc(void);
SD_Error SD_WaitReadOperation(void);
SD_Error SD_WaitWriteOperation(void);

void NVIC_SDIO_Configuration(FunctionalState Cmd);

#endif /* __SDCARD_H */
